package cn.tedu.antcolony.market.service.impl;


import cn.tedu.antcolony.market.dao.cache.IClueRedisRepository;
import cn.tedu.antcolony.market.dao.persist.repository.IClueRepository;
import cn.tedu.antcolony.market.pojo.entity.Clue;
import cn.tedu.antcolony.market.pojo.param.ClueAddNewParam;
import cn.tedu.antcolony.market.pojo.param.ClueUpdateInfoParam;
import cn.tedu.antcolony.market.pojo.vo.ClueListItemVO;
import cn.tedu.antcolony.market.pojo.vo.ClueStandardVO;
import cn.tedu.antcolony.market.service.IClueService;
import cn.tedu.antcolonycommons.ex.ServiceException;
import cn.tedu.antcolonycommons.pojo.vo.PageData;
import cn.tedu.antcolonycommons.web.ServiceCode;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;


import java.time.LocalDateTime;
import java.util.List;


@Slf4j
//日志框架
@Service
//service接口实现类添加@Service注解
public class ClueServiceImpl implements IClueService {

    @Value("${antcolony.crud.default-query-page-size}")
    private Integer defaultQueryPageSize;
    @Autowired
    private IClueRepository clueRepository;
    @Autowired
    private IClueRedisRepository clueRedisRepository;

    @Override
    public void addNew(ClueAddNewParam clueAddNewParam) {
        log.debug("开始处理【添加线索】的业务，参数：{}", clueAddNewParam);
        //得到尝试添加的线索手机号
        String phone = clueAddNewParam.getPhone();
        //统计手机号,判断手机号是否已经被占用
        int count = clueRepository.countByPhone(phone);
        log.debug("根据名称【{}】统计数量，结果：{}", phone, count);
        //判断统计结果是否大于0
        if (count > 0) {
            //是,手机号已经被占用,抛出异常
            String message = "添加失败!线索手机已经被占用!";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
        }

        //将线索数据写入到数据库中
        Clue clue = new Clue();
        BeanUtils.copyProperties(clueAddNewParam, clue);
        // 调用Mapper对象的insert()执行插入线索数据
        log.debug("即将执行插入数据，参数：{}", clue);
        //在后台添加分配、创建、修改时间
        clue.setAssignTime(LocalDateTime.now());
        clue.setGmtCreate(LocalDateTime.now());
        clue.setGmtModified(LocalDateTime.now());
        //统计插入影响数量
        int rows = clueRepository.insert(clue);
        if (rows != 1) {
            String message = "添加线索失败！服务器忙，请稍后再次尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_INSERT, message);
        }
        log.debug("将新的线索数据写入到数据库,完成!");
    }

    @Override
    public void delete1(Long id) {
        log.debug("开始处理【删除线索】的业务，参数：{}", id);
        // 检查线索是否存在，如果不存在，则抛出异常
        ClueStandardVO clue = clueRepository.getStandardByClueId(id);
        log.debug("根据线索ID={}统计匹配的线索是否存在，结果：{}", id, clue);
        if (clue == null) {
            String message = "删除线索失败，尝试删除的线索数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }
        //todo 检测此线索是否关联日志

        // 调用Mapper对象的deleteById()方法执行删除
        log.debug("即将执行删除，参数：{}", id);
        int rows = clueRepository.deleteById(id);
        if (rows != 1) {
            String message = "删除线索失败，服务器忙，请稍后再次尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_DELETE, message);
        }
    }
    @Override
    public void deleteBatch(List<String> id) {
        clueRepository.deleteByIds(id);
    }
    @Override
    public void delete2(Long id) {
        log.debug("开始处理【删除公海】的业务，参数：{}", id);
        // 检查线索是否存在，如果不存在，则抛出异常
        ClueStandardVO clue = clueRepository.getStandardByCustomerSeaId(id);
        log.debug("根据线索ID={}统计匹配的公海是否存在，结果：{}", id, clue);
        if (clue == null) {
            String message = "删除公海失败，尝试删除的公海数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }
        //todo 检测此公海是否关联日志

        // 调用Mapper对象的deleteById()方法执行删除
        log.debug("即将执行删除，参数：{}", id);
        int rows = clueRepository.deleteById(id);
        if (rows != 1) {
            String message = "删除公海失败，服务器忙，请稍后再次尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_DELETE, message);
        }
    }

    @Override
    public void updateInfoById1(Long id, ClueUpdateInfoParam clueUpdateInfoParam) {
        log.debug("开始处理【修改线索详情】的业务，ID：{}, 新数据：{}", id, clueUpdateInfoParam);
        ClueStandardVO queryResult = clueRepository.getStandardByClueId(id);
        //判断是否为null
        if (queryResult == null) {
            String message = "修改线索详情失败，线索数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }
/*
        // 调用Mapper对象的countByNameAndNotId()执行统计
        int count = clueRepository.countByNameAndNotId(id, clueUpdateInfoParam.getName());
        // 判断统计结果是否大于0
        if (count > 0) {
            // 是：名称被占用，抛出异常
            String message = "修改线索详情失败，线索名称已经被占用！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
        }*/

        // 执行修改
        Clue clue = new Clue();
        BeanUtils.copyProperties(clueUpdateInfoParam, clue);
        clue.setId(id);
        // 调用Mapper对象的update()方法执行修改
        int rows = clueRepository.update(clue);
        if (rows != 1) {
            String message = "修改线索详情失败，服务器忙，请稍后再尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_UPDATE, message);
        }
    }

    @Override
    public void updateInfoById2(Long id, ClueUpdateInfoParam clueUpdateInfoParam) {
        log.debug("开始处理【修改公海详情】的业务，ID：{}, 新数据：{}", id, clueUpdateInfoParam);
        ClueStandardVO queryResult = clueRepository.getStandardByCustomerSeaId(id);
        //判断是否为null
        if (queryResult == null) {
            String message = "修改公海详情失败，公海数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }

        // 调用Mapper对象的countByNameAndNotId()执行统计
        int count = clueRepository.countByNameAndNotId(id, clueUpdateInfoParam.getName());
        // 判断统计结果是否大于0
        if (count > 0) {
            // 是：名称被占用，抛出异常
            String message = "修改公海详情失败，公海名称已经被占用！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_CONFLICT, message);
        }

        // 执行修改
        Clue clue = new Clue();
        BeanUtils.copyProperties(clueUpdateInfoParam, clue);
        clue.setId(id);
        // 调用Mapper对象的update()方法执行修改
        int rows = clueRepository.update(clue);
        if (rows != 1) {
            String message = "修改公海详情失败，服务器忙，请稍后再尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_UPDATE, message);
        }
    }


    @Override
    public ClueStandardVO getStandardByClueId(Long id) {
        log.debug("开始处理【根据ID查询线索详情】的业务，参数：{}", id);
        ClueStandardVO queryResult = clueRepository.getStandardByClueId(id);
        if (queryResult == null) {
            String message = "查询线索详情失败，线索数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }
        return queryResult;
    }

    @Override
    public ClueStandardVO getStandardByCustomerSeaId(Long id) {
        log.debug("开始处理【根据ID查询公海详情】的业务，参数：{}", id);
        ClueStandardVO queryResult = clueRepository.getStandardByCustomerSeaId(id);
        if (queryResult == null) {
            String message = "查询线索详情失败，线索数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }
        return queryResult;
    }

    //转入公海
    @Override
    public int transform(Long id) {
        log.debug("开始处理【转入公海】的业务，参数：{}", id);
        ClueStandardVO queryResult = clueRepository.getStandardByClueId(id);
        log.debug("根据ID获取匹配的线索，结果为：{}", queryResult);
        if (queryResult == null) {
            String message = "转入公海失败，线索数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }
        int row1 = clueRepository.deleteAttribution(id);
        int row2 = clueRepository.transformToSeaById(id);
        if (row1 != 1 || row2 != 1) {
            String message = "线索转公海失败，服务器忙，请稍后再尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_UPDATE, message);
        }
        return 1;
    }

    //领取公海
    @Override
    public int pickCustomerSea(Long id,String name) {
        log.debug("开始处理【领取公海】的业务，参数：{}", id);
        ClueStandardVO queryResult = clueRepository.getStandardByCustomerSeaId(id);
        log.debug("根据ID获取匹配的公海，结果为：{}", queryResult);
        if (queryResult == null) {
            String message = "领取公海失败，公海数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }
        int row1 = clueRepository.changeAttribution(id,name);
        int row2 = clueRepository.transformToClueById(id);
        if (row1 != 1 || row2 != 1) {
            String message = "线索转公海失败，服务器忙，请稍后再尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_UPDATE, message);
        }
        return 1;
    }

    //线索转让
    @Override
    public int transferClue(Long id, String name) {
        log.debug("开始处理【线索转让】的业务，参数：{},转让给{}", id,name);
        ClueStandardVO queryResult = clueRepository.getStandardByClueId(id);
        log.debug("根据ID获取匹配的线索，结果为：{}", queryResult);
        if (queryResult == null) {
            String message = "转让线索失败，线索数据不存在！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_NOT_FOUND, message);
        }
        int row1 = clueRepository.deleteAttribution(id);
        int row2 =clueRepository.changeAttribution(id, name);
        if (row1 != 1 || row2 != 1) {
            String message = "转让线索失败，服务器忙，请稍后再尝试！";
            log.warn(message);
            throw new ServiceException(ServiceCode.ERR_UPDATE, message);
        }
        return 1;
    }

    @Override
    public int newCustomer(Long id) {
        return 0;
    }

    @Override
    public PageData<ClueListItemVO> list1(Integer page) {
        log.debug("开始处理【查询线索列表】的业务，页码：{}", page);
        PageData<ClueListItemVO> pageData = clueRepository.listClue(page, defaultQueryPageSize);
        return pageData;
    }

    @Override
    public PageData<ClueListItemVO> list1(Integer page, Integer pageSize) {
        log.debug("开始处理【查询线索列表】的业务，页码：{}，每页记录数：{}", page, pageSize);
        PageData<ClueListItemVO> pageData = clueRepository.listClue(page, pageSize);
        log.debug("查询完成,即将返回: {}", pageData);
        return pageData;
    }

    @Override
    public PageData<ClueListItemVO> list2(Integer page) {
        log.debug("开始处理【查询公海列表】的业务，页码：{}", page);
        PageData<ClueListItemVO> pageData = clueRepository.listCustomerSea(page, defaultQueryPageSize);
        return pageData;
    }

    @Override
    public PageData<ClueListItemVO> list2(Integer page, Integer pageSize) {
        log.debug("开始处理【查询公海列表】的业务，页码：{}，每页记录数：{}", page, pageSize);
        PageData<ClueListItemVO> pageData = clueRepository.listCustomerSea(page, pageSize);
        log.debug("查询完成,即将返回: {}", pageData);
        return pageData;
    }

    @Override
    public void rebuildCache() {
        log.debug("开始处理【重建线索缓存】的业务，无参数");
        // 删除缓存中的线索列表
        clueRedisRepository.deleteList();
        // 从数据库中查询所有线索的列表
        List<ClueListItemVO> list = clueRepository.list(1, defaultQueryPageSize).getList();
        // 将线索列表写入到缓存中
        clueRedisRepository.save(list);

        // 删除缓存中所有的线索的数据项
        clueRedisRepository.deleteAllItem();
        // 遍历线索列表的数据
        for (ClueListItemVO clueListItemVO : list) {
            // 获取每个线索数据的ID，并根据此ID从数据库中查询线索的详情
            ClueStandardVO clueStandardVO
                    = clueRepository.getStandardByClueId(clueListItemVO.getId());
            // 将每一个线索详情写入到缓存中
            clueRedisRepository.save(clueStandardVO);
        }
    }




}
